package com.share.device.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.share.common.core.exception.ServiceException;
import com.share.device.service.IMapService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import java.util.HashMap;
import java.util.Map;

@Slf4j
@Service
@SuppressWarnings({"unchecked", "rawtypes"})
public class MapServiceImpl implements IMapService {

    @Autowired
    private RestTemplate restTemplate;

    @Value("${tencent.map.key}")
    private String key;

    /**
     * 根据经纬度计算详细地址
     *
     * @param keyword
     * @return
     */
    public JSONObject  calculateLatLng(String keyword) {
        String url = "https://apis.map.qq.com/ws/geocoder/v1/?address={address}&key={key}";

        Map<String, String> map = new HashMap<>();
        map.put("address", keyword);
        map.put("key", key);

        JSONObject response = restTemplate.getForObject(url, JSONObject.class, map);
        log.error("调用接口失败原因: {}", response.get("message"));
        if (response.getIntValue("status") != 0) {
            throw new ServiceException("地图解析异常,原因是："+ response.get("message"));
        }

        //返回第一条最佳线路
        JSONObject result = response.getJSONObject("result");
        System.out.println(result.toJSONString());
        return result.getJSONObject("location");
    }

    /**
     * 计算距离
     *
     * @param startLongitude
     * @param startLatitude
     * @param endLongitude
     * @param endLatitude
     * @return
     */
    public Double calculateDistance(String startLongitude, String startLatitude, String endLongitude, String endLatitude) {
        try {
            // 检查坐标是否有效
//            if (!isValidCoordinate(startLongitude, startLatitude) || !isValidCoordinate(endLongitude, endLatitude)) {
//                log.warn("无效的坐标值: 起点({},{}) 终点({},{})", startLatitude, startLongitude, endLatitude, endLongitude);
//                return 0.0; // 无效坐标返回0距离
//            }

            // 标准化坐标精度，避免因为精度差异导致的问题
            double startLat = Double.parseDouble(startLatitude);
            double startLng = Double.parseDouble(startLongitude);
            double endLat = Double.parseDouble(endLatitude);
            double endLng = Double.parseDouble(endLongitude);

            // 检查起点和终点是否太近（距离小于10米）
            double straightDistance = calculateStraightLineDistance(startLat, startLng, endLat, endLng);
//            if (straightDistance < 10) {
//                log.info("起点和终点距离太近 ({}米)，直接返回直线距离", straightDistance);
//                return straightDistance;
//            }
            // 确保坐标格式一致，使用相同的精度
            String formattedStartLat = String.format("%.6f", startLat);
            String formattedStartLng = String.format("%.6f", startLng);
            String formattedEndLat = String.format("%.6f", endLat);
            String formattedEndLng = String.format("%.6f", endLng);

            String url = "https://apis.map.qq.com/ws/direction/v1/walking/?from={from}&to={to}&key={key}";

            Map<String, String> map = new HashMap<>();
            map.put("from", formattedStartLat + "," + formattedStartLng);
            map.put("to", formattedEndLat + "," + formattedEndLng);
            map.put("key", key);

            log.debug("请求腾讯地图API: 起点({},{}) 终点({},{})",
                    formattedStartLat, formattedStartLng, formattedEndLat, formattedEndLng);

            JSONObject result = restTemplate.getForObject(url, JSONObject.class, map);
            if (result.getIntValue("status") != 0) {
                log.warn("地图服务调用失败: {} - 起点({},{}) 终点({},{})",
                        result.getString("message"), formattedStartLat, formattedStartLng,
                        formattedEndLat, formattedEndLng);

                // 使用直线距离作为备选方案
                return straightDistance;
            }

            //返回第一条最佳线路
            JSONObject route = result.getJSONObject("result").getJSONArray("routes").getJSONObject(0);
            // 单位：米
            return route.getBigDecimal("distance").doubleValue();
        } catch (Exception e) {
            log.error("计算距离时发生异常: {}", e.getMessage(), e);
            // 发生异常时使用直线距离计算
            try {
                return calculateStraightLineDistance(
                        Double.parseDouble(startLatitude), Double.parseDouble(startLongitude),
                        Double.parseDouble(endLatitude), Double.parseDouble(endLongitude));
            } catch (Exception ex) {
                log.error("直线距离计算也失败: {}", ex.getMessage());
                return 0.0; // 所有计算都失败时返回0
            }
        }
    }

    /**
     * 检查坐标是否有效
     */
    private boolean isValidCoordinate(String longitude, String latitude) {
        try {
            double lng = Double.parseDouble(longitude);
            double lat = Double.parseDouble(latitude);

            // 经度范围: -180 到 180
            // 纬度范围: -90 到 90
            return lng >= -180 && lng <= 180 && lat >= -90 && lat <= 90;
        } catch (NumberFormatException e) {
            return false;
        }
    }

    /**
     * 计算两点间的直线距离（使用Haversine公式）
     * 单位：米
     */
    private Double calculateStraightLineDistance(double startLat, double startLng, double endLat, double endLng) {
        final int R = 6371; // 地球半径，单位：千米

        double latDistance = Math.toRadians(endLat - startLat);
        double lngDistance = Math.toRadians(endLng - startLng);

        double a = Math.sin(latDistance / 2) * Math.sin(latDistance / 2)
                + Math.cos(Math.toRadians(startLat)) * Math.cos(Math.toRadians(endLat))
                * Math.sin(lngDistance / 2) * Math.sin(lngDistance / 2);

        double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));

        // 转换为米
        return R * c * 1000;
    }
}
